export const group = [
    '标号',
    '解除锁定',
    '对象可见性',
    '常用:点',
    '主线',
    '衬线',
    '填充',
    '注记',
    '子标号',
]
export const displayName = ['锁定', '可见性', 'LibID', 'Code']
export const displayLineStyleName = ['线宽', '线颜色', '线型', '线透明度']
export const displaySurroundLineName = [
    '衬线类型',
    '衬线宽',
    '衬线颜色',
    '衬线透明度',
]
export const displayFillStyleName = [
    '填充模式',
    '填充色',
    '填充透明度',
    '渐变填充方式',
    '填充背景色',
    '填充背景透明度',
    '渐变填充角度',
    '渐变填充水平偏移',
    '渐变填充竖直偏移',
]
export const displayNameDot = [
    '旋转角度',
    '随图缩放',
    '镜像',
    '标号级别',
    '位置点偏移',
    '偏移线类型',
    '宽高锁定',
    '标号Width',
    '标号Height',
]
export const displayTextContentName = [
    '注记内容',
    '注记位置',
    '注记大小',
    '注记颜色',
    '注记字体',
    '注记距离',
    '字间距',
    '字宽百分比',
    '字体描边',
    '描边色',
    '描边宽度',
    '文字背景',
    '背景色',
    '文字阴影',
    '阴影色',
    '阴影偏移量X',
    '阴影偏移量Y',
]
export const groupNew = [
    '组合类型',
    '箭头类型',
    '沿线类型',
    '边框属性',
    '半径',
    '轨道设置',
    '节点设置',
    '连线类型',
    '折线设置',
]
export const displayNameNew = [
    '箭头',
    '箭身',
    '箭尾',
    '起始',
    '终止',
    '路径线',
    '贝塞尔曲线',
    '显示箭头',
    '避让',
    '标注框边框',
    '圆角边框',
    '对象标注边框',
    '半径类型',
    '半径角度',
    '注记一',
    '注记二',
    '卫星轨道',
    '节点类型',
    '节点旋转角度',
    '对象间连线',
    '折线显示',
    '文字对齐方式',
]

function checkboxValueToString(checkboxValue) {
    if (checkboxValue === true || checkboxValue === 'true') {
        // return 'true'
        return true
    } else if (checkboxValue === false || checkboxValue === 'false') {
        // return 'false'
        return false
    }
}
export function fromCheckboxValue(checkboxStr) {
    if (checkboxStr === 'true' || checkboxStr === true) {
        return true
    } else if (checkboxStr === 'false' || checkboxStr === false) {
        return false
    }
}

/***
 * 对象可见性
 */
function getDisplayRows() {
    const rows = []
    rows.push({ value: 'display', text: '显示' })
    rows.push({ value: 'none', text: '不显示' })
    return rows
}
function displayToString(display) {
    if (display && display === 'none') {
        return '不显示'
    }
    return '显示'
}
/**
 * 8C使用线型
 */
function get8CLineStyleRows() {
    const rows = []
    rows.push({ value: 'solid', text: 'solid' })
    rows.push({ value: 'dot', text: 'dot' })
    rows.push({ value: 'dash', text: 'dash' })
    rows.push({ value: 'dashdot', text: 'dashdot' })
    rows.push({ value: 'longdash', text: 'longdash' })
    rows.push({ value: 'longdashdot', text: 'longdashdot' })
    return rows
}
/**
 * 9D使用线型
 */
function lineStyleToString(lineStyle) {
    if (lineStyle == 1) return '长虚线'
    else if (lineStyle == 2) return '由点构成的直线'
    else if (lineStyle == 3) return '由线划线段组成的直线'
    else if (lineStyle == 4) return '由重复的线划点图案构成的直线'
    else if (lineStyle == 0) return '实线'
    else if (lineStyle) return '实线'
}
function getLineStyleRows() {
    const rows = []
    rows.push({ value: '0', text: '实线' }) //实线(solid)
    rows.push({ value: '1', text: '长虚线' }) //长虚线(longdash) //虚线(dash)
    rows.push({ value: '2', text: '由点构成的直线' }) //由点构成的直线(dot)
    rows.push({ value: '3', text: '由线划线段组成的直线' }) //由线划线段组成的直线(dashdot)(longdashdot)
    rows.push({ value: '4', text: '由重复的线划点图案构成的直线' }) //由重复的划线点图案构成的直线
    return rows
}
/**
 *注记位置
 */
function getAnnotationRows(geometry) {
    const annotations = []
    annotations.push({ value: '0', text: '左上' })
    annotations.push({ value: '1', text: '左下' })
    annotations.push({ value: '2', text: '右上' })
    annotations.push({ value: '3', text: '右下' })
    annotations.push({ value: '4', text: '上' })
    annotations.push({ value: '5', text: '下' })
    annotations.push({ value: '6', text: '左' })
    annotations.push({ value: '7', text: '右' })
    if (geometry.symbolData && geometry.symbolData.middleMarkExist)
        annotations.push({ value: '8', text: '中间' })
    return annotations
}
function annotationToString(annotation) {
    if (annotation === 0) return '左上'
    else if (annotation === 1) return '左下'
    else if (annotation === 2) return '右上'
    else if (annotation === 3) return '右下'
    else if (annotation === 4) return '上'
    else if (annotation === 5) return '下'
    else if (annotation === 6) return '左'
    else if (annotation === 7) return '右'
    else if (annotation === 8) return '中间'
}
/**
 * 标号级别
 */
function symbolRankToString(symbolRank) {
    if (symbolRank == 0) return '无级别'
    else if (symbolRank == 1) return '军区级'
    else if (symbolRank == 2) return '副大军区级'
    else if (symbolRank == 3) return '集团军级'
    else if (symbolRank == 4) return '师级'
    else if (symbolRank == 5) return '旅级'
    else if (symbolRank == 6) return '团级'
    else if (symbolRank == 7) return '营级'
    else if (symbolRank == 8) return '连级'
    else if (symbolRank == 9) return '排级'
}
function getSymbolRankRows(geometry) {
    let symbolRanks = []
    if (geometry.symbolData && geometry.symbolData.symbolRanks) {
        symbolRanks = geometry.symbolData.symbolRanks
    }
    const rows = []
    rows.push({ value: '0', text: '无级别' })
    for (let i = 0; i < symbolRanks.length; i++) {
        if (symbolRanks[i] == 1) rows.push({ value: '1', text: '军区级' })
        else if (symbolRanks[i] == 2)
            rows.push({ value: '2', text: '副大军区级' })
        else if (symbolRanks[i] == 3)
            rows.push({ value: '3', text: '集团军级' })
        else if (symbolRanks[i] == 4) rows.push({ value: '4', text: '师级' })
        else if (symbolRanks[i] == 5) rows.push({ value: '5', text: '旅级' })
        else if (symbolRanks[i] == 6) rows.push({ value: '6', text: '团级' })
        else if (symbolRanks[i] == 7) rows.push({ value: '7', text: '营级' })
        else if (symbolRanks[i] == 8) rows.push({ value: '8', text: '连级' })
        else if (symbolRanks[i] == 9) rows.push({ value: '9', text: '排级' })
    }
    return rows
}
/**
 * 衬线
 */
function surroundLineTypeToString(symbolType, surroundLineType) {
    if (symbolType === SuperMap.Plot.SymbolType.DOTSYMBOL) {
        if (surroundLineType === 0) return '无衬线'
        else if (surroundLineType === 1) return '有衬线'
    } else {
        if (surroundLineType === 0) return '无衬线'
        else if (surroundLineType === 1) return '内侧衬线'
        else if (surroundLineType === 2) return '外侧衬线'
        else if (surroundLineType === 3) return '双侧衬线'
    }
}
function getSurroundLineTypeRows(symbolType) {
    const rows = []
    if (symbolType === SuperMap.Plot.SymbolType.DOTSYMBOL) {
        rows.push({ value: '0', text: '无衬线' })
        rows.push({ value: '1', text: '有衬线' })
    } else {
        rows.push({ value: '0', text: '无衬线' })
        rows.push({ value: '1', text: '内侧衬线' })
        rows.push({ value: '2', text: '外侧衬线' })
        rows.push({ value: '3', text: '双侧衬线' })
    }
    return rows
}
/**
 * 填充
 */
function fillGradientModeToString(fillGradientMode) {
    if (fillGradientMode === 'NONE') {
        return '无渐变'
    } else if (fillGradientMode === 'LINEAR') {
        return '线性渐变'
    } else if (fillGradientMode === 'RADIAL') {
        return '辐射渐变'
    } else {
        return '无渐变'
    }
}
function getFillGradientModeRows() {
    const rows = []
    rows.push({ value: 'NONE', text: '无渐变' })
    rows.push({ value: 'LINEAR', text: '线性渐变' })
    rows.push({ value: 'RADIAL', text: '辐射渐变' })
    return rows
}
function fillToString(fillSymbolID, selectfeature) {
    if (fillSymbolID === 0) {
        return '实填充'
    } else if (fillSymbolID === 1) {
        return '无填充'
    }
    if (selectfeature.symbolType !== SuperMap.Plot.SymbolType.SYMBOLTEXT) {
        if (fillSymbolID === 2) {
            return '向上斜填充'
        } else if (fillSymbolID === 3) {
            return '十字填充'
        } else if (fillSymbolID === 4) {
            return '交叉填充'
        } else if (fillSymbolID === 5) {
            return '反斜线填充'
        } else if (fillSymbolID === 6) {
            return '水平填充'
        } else if (fillSymbolID === 7) {
            return '竖直填充'
        }
    }
}
function getFillRows(selectfeature) {
    const rows = []
    rows.push({ value: 0, text: '实填充' })
    rows.push({ value: 1, text: '无填充' })
    if (selectfeature.symbolType !== SuperMap.Plot.SymbolType.SYMBOLTEXT) {
        rows.push({ value: 2, text: '向上斜填充' })
        rows.push({ value: 3, text: '十字填充' })
        rows.push({ value: 4, text: '交叉填充' })
        rows.push({ value: 5, text: '反斜线填充' })
        rows.push({ value: 6, text: '水平填充' })
        rows.push({ value: 7, text: '竖直填充' })
    }
    return rows
}
/**
 * 偏移线类型
 */
function positionOffsetTypeToString(positionOffsetType) {
    if (positionOffsetType === 0) {
        return '直线'
    } else if (positionOffsetType === 1) {
        return '线粗渐变'
    }
}
function getPositionOffsetTypeRows() {
    const rows = []
    rows.push({ value: '0', text: '直线' })
    rows.push({ value: '1', text: '线粗渐变' })
    return rows
}
/**
 * 沿线注记
 */
function getShowRows() {
    const rows = []
    rows.push({ value: 'true', text: '显示' })
    rows.push({ value: 'false', text: '不显示' })
    return rows
}
function showToString(show) {
    if (show === true) {
        return '显示'
    } else if (show === false) {
        return '不显示'
    }
}
function relLineTextToString(relLineText) {
    if (relLineText === SuperMap.Plot.RelLineText.ONLINE) return '线上'
    else if (relLineText === SuperMap.Plot.RelLineText.ONLEFTLINE) return '线左'
    else if (relLineText === SuperMap.Plot.RelLineText.ONRIGHTLINE)
        return '线右'
    else if (relLineText === SuperMap.Plot.RelLineText.ONBOTHLINE) return '双侧'
}
function getRelLineTextRows() {
    const annotations = []
    annotations.push({ value: '0', text: '线上' })
    annotations.push({ value: '1', text: '线左' })
    annotations.push({ value: '2', text: '线右' })
    annotations.push({ value: '3', text: '双侧' })
    return annotations
}
/***
 * 对象间连线
 */
function lineRelationTypeToString(lineRelationType) {
    if (lineRelationType == 0) return '实直线'
    else if (lineRelationType == 1) return '虚直线'
    else if (lineRelationType == 2) return '箭头线'
}
function getLineRelationTypeRows() {
    const rows = []
    rows.push({ value: '0', text: '实直线' })
    rows.push({ value: '1', text: '虚直线' })
    rows.push({ value: '2', text: '箭头线' })
    return rows
}
/**
 * 航线节点类型
 */
function routeNodeTypeToString(routeNodeType) {
    if (routeNodeType === SuperMap.Plot.RouteNodeType.AIMING) return '瞄准点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.COMMONROUTE)
        return '普通航路点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.EXPANDING)
        return '展开点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.INITIAL)
        return '初始点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.LANCH) return '发射点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.RENDEZVOUS)
        return '会合点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.STANDBY)
        return '待机点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.SUPPLY)
        return '补给点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.TAKEOFF)
        return '起飞点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.TURNING)
        return '转弯点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.VISUALINITAL)
        return '可视初始点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.VOLLEY)
        return '齐射点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.WEAPONLAUNCH)
        return '武器发射点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.TARGET)
        return '目标点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.ATTACK)
        return '攻击点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.SUPPRESS)
        return '压制点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.EIGHTSPIRAL)
        return '八字盘旋点'
    else if (routeNodeType == SuperMap.Plot.RouteNodeType.HAPPYVALLEY)
        return '跑马圈点'
}
function getRouteNodeTypeRows() {
    const rows = []
    rows.push({ value: 'AIMING', text: '瞄准点' })
    rows.push({ value: 'COMMONROUTE', text: '普通航路点' })
    rows.push({ value: 'EXPANDING', text: '展开点' })
    rows.push({ value: 'INITIAL', text: '初始点' })
    rows.push({ value: 'LANCH', text: '发射点' })
    rows.push({ value: 'RENDEZVOUS', text: '会合点' })
    rows.push({ value: 'STANDBY', text: '待机点' })
    rows.push({ value: 'SUPPLY', text: '补给点' })
    rows.push({ value: 'TAKEOFF', text: '起飞点' })
    rows.push({ value: 'TURNING', text: '转弯点' })
    rows.push({ value: 'VISUALINITAL', text: '可视初始点' })
    rows.push({ value: 'VOLLEY', text: '齐射点' })
    rows.push({ value: 'WEAPONLAUNCH', text: '武器发射点' })
    rows.push({ value: 'TARGET', text: '目标点' })
    rows.push({ value: 'ATTACK', text: '攻击点' })
    rows.push({ value: 'SUPPRESS', text: '压制点' })
    rows.push({ value: 'EIGHTSPIRAL', text: '八字盘旋点' })
    rows.push({ value: 'HAPPYVALLEY', text: '跑马圈点' })
    return rows
}
/**
 *箭头线
 */
function arrowTypeToString(arrowType) {
    if (arrowType == 0) return '双线箭头'
    else if (arrowType == 1) return '实心三角形'
    else if (arrowType == 2) return '无箭头'
}
function getArrowTypeRows() {
    const rows = []
    rows.push({ value: '0', text: '双线箭头' })
    rows.push({ value: '1', text: '实心三角形' })
    rows.push({ value: '2', text: '无箭头' })
    return rows
}
/**
 * 扇形区域
 */
function radiusTypeToString(radiusType) {
    if (radiusType == 0) return '不显示'
    else if (radiusType == 1) return '直线'
    else if (radiusType == 2) return '箭头线'
}
function getRadiusTypeRows() {
    const rows = []
    rows.push({ value: '0', text: '不显示' })
    rows.push({ value: '1', text: '直线' })
    rows.push({ value: '2', text: '箭头线' })
    return rows
}
/**
 * 标注框
 */
function textBoxTypeToString(textBoxType) {
    if (textBoxType == 0) return '带角矩形边框'
    else if (textBoxType == 1) return '矩形边框'
    else if (textBoxType == 3) return '无边框'
}
function getTextBoxTypeRows() {
    const rows = []
    rows.push({ value: '0', text: '带角矩形边框' })
    rows.push({ value: '1', text: '矩形边框' })
    rows.push({ value: '3', text: '无边框' })
    return rows
}
/**
 * 线型标注框
 */
function lineMarkingTypeToString(lineMarkingType) {
    if (lineMarkingType === 1) {
        return '矩形边框'
    } else if (lineMarkingType === 2) {
        return '线型底边'
    }
}
function getLineMarkingTypeRows() {
    const rows = []
    rows.push({ value: '1', text: '矩形边框' })
    rows.push({ value: '2', text: '线型底边' })
    return rows
}
/**
 * 复合箭头
 * 箭头、箭身、箭尾
 */
function getArrowHeadTypeRows() {
    const rows = []
    rows.push({ value: '0', text: '双线箭头' })
    rows.push({ value: '2', text: '燕尾箭头' })
    rows.push({ value: '3', text: '实心三角形' })
    rows.push({ value: '6', text: '新燕尾箭头' })
    rows.push({ value: '-1', text: '无箭头' })
    return rows
}
function arrowHeadTypeToString(arrowHeadType) {
    if (arrowHeadType == 0) return '双线箭头'
    else if (arrowHeadType == 2) return '燕尾箭头'
    else if (arrowHeadType == 3) return '实心三角形'
    else if (arrowHeadType == 6) return '新燕尾箭头'
    else if (arrowHeadType == -1) return '无箭头'
}
function arrowBodyTypeToString(arrowBodyType) {
    if (arrowBodyType == 0) return '折线'
    else if (arrowBodyType == 1) return '贝塞尔曲线'
    else if (arrowBodyType == 5) return '新增箭身'
}
function getArrowBodyTypeRows() {
    const rows = []
    rows.push({ value: '0', text: '折线' })
    rows.push({ value: '1', text: '贝塞尔曲线' })
    rows.push({ value: '5', text: '新增箭身' })
    return rows
}
function arrowTailTypeToString(arrowTailType) {
    if (arrowTailType == 0) return '无箭尾'
    else if (arrowTailType == 1) return '直线箭尾'
    else if (arrowTailType == 3) return '燕尾箭尾'
}
function getArrowTailTypeRows() {
    const rows = []
    rows.push({ value: '0', text: '无箭尾' })
    rows.push({ value: '1', text: '直线箭尾' })
    rows.push({ value: '3', text: '燕尾箭尾' })
    return rows
}
/**
 * 线面标号子标号
 */
function libIDToString(libID) {
    if (libID == 421) return '421(警用库)'
    else if (libID == 100) return '100(军队库)'
    else if (libID == 123) return '123(武警库)'
    else if (libID == 900) return '900(人防库)'
}
function subSymbolsTypeString(subSymbolsLength, geometry) {
    if (subSymbolsLength === 0) {
        return ''
    } else {
        if (geometry.libID === 100) {
            if (geometry.getSubSymbols()[0].code === 100) {
                return '陆军'
            } else if (geometry.getSubSymbols()[0].code === 200) {
                return '海军'
            } else if (geometry.getSubSymbols()[0].code === 300) {
                return '空军'
            }
        } else if (geometry.libID === 123) {
            if (geometry.getSubSymbols()[0].code === 10101) {
                return '武装警察部队'
            } else if (geometry.getSubSymbols()[0].code === 10102) {
                return '防爆装甲'
            } else if (geometry.getSubSymbols()[0].code === 10103) {
                return '火炮'
            }
        } else if (geometry.libID === 900) {
            if (geometry.getSubSymbols()[0].code === 910200) {
                return '人民防空重点城市'
            } else if (geometry.getSubSymbols()[0].code === 910300) {
                return '人民防空基本指挥所'
            } else if (geometry.getSubSymbols()[0].code === 910402) {
                return '水路抢修专业队'
            }
        } else if (geometry.libID === 0) {
            if (geometry.getSubSymbols()[0].code === 9) {
                return '刑警'
            } else if (geometry.getSubSymbols()[0].code === 80103) {
                return '交警'
            } else if (geometry.getSubSymbols()[0].code === 80109) {
                return '专业警'
            }
        }
    }
}
function getSubSymbolsTypeRows(geometry) {
    const rows = []
    rows.push({ value: '0', text: '' })
    if (geometry.libID === 100) {
        rows.push({ value: '100', text: '陆军' })
        rows.push({ value: '200', text: '海军' })
        rows.push({ value: '300', text: '空军' })
    } else if (geometry.libID === 123) {
        rows.push({ value: '10101', text: '武装警察部队' })
        rows.push({ value: '10102', text: '防爆装甲' })
        rows.push({ value: '10103', text: '火炮' })
    } else if (geometry.libID === 900) {
        rows.push({ value: '910200', text: '人民防空重点城市' })
        rows.push({ value: '910300', text: '人民防空基本指挥所' })
        rows.push({ value: '910402', text: '水路抢修专业队' })
    } else if (geometry.libID === 0) {
        rows.push({ value: '9', text: '刑警' })
        rows.push({ value: '80103', text: '交警' })
        rows.push({ value: '80109', text: '专业警' })
    }
    return rows
}
/**
 * 文字对齐
 * 注记指示框、标注框、多角标注框、线型标注框
 */
function fontAlignTypeToString(alignType) {
    if (alignType === 'lm') return '左对齐'
    else if (alignType === 'rm') return '右对齐'
    else if (alignType === 'cm') return '中间对齐'
    else if (alignType === 'lt') return '左上对齐'
    else if (alignType === 'lb') return '左下对齐'
    else if (alignType === 'rt') return '右上对齐'
    else if (alignType === 'rb') return '右下对齐'
}
function getFontAlignTypeRows() {
    const rows = []
    rows.push({ value: '0', text: '左对齐' })
    rows.push({ value: '1', text: '右对齐' })
    rows.push({ value: '2', text: '居中对齐' })
    rows.push({ value: '3', text: '左上对齐' })
    rows.push({ value: '4', text: '左下对齐' })
    rows.push({ value: '5', text: '右上对齐' })
    rows.push({ value: '6', text: '右下对齐' })
    return rows
}
export function fontAlignTypeValue(value) {
    if (value === '0') {
        return 'lm'
    } else if (value === '1') {
        return 'rm'
    } else if (value === '2') {
        return 'cm'
    } else if (value === '3') {
        return 'lt'
    } else if (value === '4') {
        return 'lb'
    } else if (value === '5') {
        return 'rt'
    } else if (value === '6') {
        return 'rb'
    }
}

//判断标号类型分类
function checkSymbolType(selectfeature) {
    if (
        selectfeature.symbolType === SuperMap.Plot.SymbolType.GROUPOBJECT ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.FLAGGROUP ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.AIRROUTE ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.NAVYROUTE ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.MISSILEROUTE ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.ROUTENODE ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.LITERATESIGN ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.SATELLITE ||
        selectfeature.symbolType ===
            SuperMap.Plot.SymbolType.SATELLITETIMEWINDOWS ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.NAVYDEPLOYMENT ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.AIRDEPLOYMENT ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.SYMBOLTEXT ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.SYMBOLTEXT1 ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.TEXTSYMBOL
    ) {
        return false
    } else {
        return true
    }
}

function isCanAddText(selectfeature) {
    if (
        selectfeature.symbolType === SuperMap.Plot.SymbolType.POLYLINESYMBOL || //直线
        selectfeature.symbolType === SuperMap.Plot.SymbolType.PARALLELOGRAM || //平行四边形
        selectfeature.symbolType === SuperMap.Plot.SymbolType.CIRCLESYMBOL || //圆
        selectfeature.symbolType === SuperMap.Plot.SymbolType.ELLIPSESYMBOL || //椭圆
        selectfeature.symbolType === SuperMap.Plot.SymbolType.REGULARPOLYGON || //正多边形
        selectfeature.symbolType ===
            SuperMap.Plot.SymbolType.ARBITRARYPOLYGONSYMBOL || //任意多边形
        selectfeature.symbolType ===
            SuperMap.Plot.SymbolType.POLYBEZIERSYMBOL || //贝塞尔曲线
        selectfeature.symbolType ===
            SuperMap.Plot.SymbolType.POLYBEZIERCLOSESYMBOL || //闭合贝塞尔曲线
        selectfeature.symbolType === SuperMap.Plot.SymbolType.KIDNEY || //集结地
        selectfeature.symbolType === SuperMap.Plot.SymbolType.BRACESYMBOL || //大括号
        selectfeature.symbolType === SuperMap.Plot.SymbolType.TRAPEZOIDSYMBOL || //梯形
        selectfeature.symbolType === SuperMap.Plot.SymbolType.RECTANGLESYMBOL || //矩形
        selectfeature.symbolType === SuperMap.Plot.SymbolType.CHORDSYMBOL || //弓形
        selectfeature.symbolType === SuperMap.Plot.SymbolType.PIESYMBOL || //扇形
        selectfeature.symbolType === SuperMap.Plot.SymbolType.ARCSYMBOL || //弧线
        selectfeature.symbolType === SuperMap.Plot.SymbolType.PARALLELLINE || //平行线
        selectfeature.symbolType === SuperMap.Plot.SymbolType.ANNOFRAMESYMBOL || //注记指示框
        selectfeature.symbolType ===
            SuperMap.Plot.SymbolType.CONCENTRICCIRCLE || //同心圆
        selectfeature.symbolType ===
            SuperMap.Plot.SymbolType.COMBINATIONALCIRCLE || //组合圆
        selectfeature.symbolType ===
            SuperMap.Plot.SymbolType.ANNOFRAMESYMBOLM || //多角标注框
        selectfeature.symbolType === SuperMap.Plot.SymbolType.SYMBOLTEXTBOX || //标注框
        selectfeature.symbolType === SuperMap.Plot.SymbolType.FREECURVE || //自由曲线
        selectfeature.symbolType === SuperMap.Plot.SymbolType.NODECHAIN || //节点链
        selectfeature.symbolType === SuperMap.Plot.SymbolType.RUNWAY || //跑道形
        selectfeature.symbolType === SuperMap.Plot.SymbolType.CURVEEIGHT || //8字形
        selectfeature.symbolType === SuperMap.Plot.SymbolType.ARROWLINE || //箭头线
        selectfeature.symbolType === SuperMap.Plot.SymbolType.PATHTEXT || //沿线注记
        selectfeature.symbolType === SuperMap.Plot.SymbolType.POLYGONREGION || //多边形区域
        selectfeature.symbolType === SuperMap.Plot.SymbolType.ARCREGION || //扇形区域
        selectfeature.symbolType === SuperMap.Plot.SymbolType.LINEMARKING //线型标注
    ) {
        return true
    }
}

function symbolPropertyObject(selectfeature, styleObject) {
    //线形：线宽
    const lineWidthObj = new Object()
    lineWidthObj.group = group[4]
    lineWidthObj.name = displayLineStyleName[0]
    lineWidthObj.editor = 'text'
    if (styleObject.weight !== undefined) {
        lineWidthObj.value = styleObject.weight
    } else {
        if (selectfeature.symbolType === SuperMap.Plot.SymbolType.GROUPOBJECT) {
            lineWidthObj.value = selectfeature.getStrokeWidth()
        } else {
            lineWidthObj.value = styleObject.strokeWidth
        }
    }

    //线形：线色
    const lineColorObj = new Object()
    lineColorObj.group = group[4]
    lineColorObj.name = displayLineStyleName[1]
    lineColorObj.editor = 'colorpicker'
    if (styleObject.color !== undefined) {
        lineColorObj.value = styleObject.color
    } else {
        if (selectfeature.symbolType === SuperMap.Plot.SymbolType.GROUPOBJECT) {
            lineColorObj.value = selectfeature.getStrokeColor()
        } else {
            lineColorObj.value = styleObject.strokeColor
        }
    }

    //线形：线型
    const lineStyleObj = new Object()
    lineStyleObj.group = group[4]
    lineStyleObj.name = displayLineStyleName[2]
    if (styleObject.lineSymbolID !== undefined) {
        lineStyleObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getLineStyleRows(),
            },
        }
        lineStyleObj.value = lineStyleToString(styleObject.lineSymbolID)
    } else {
        lineStyleObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: get8CLineStyleRows(),
            },
        }
        lineStyleObj.value = styleObject.strokeDashstyle
    }

    //线形：线透明度
    const lineOpaqueRateObj = new Object()
    lineOpaqueRateObj.group = group[4]
    lineOpaqueRateObj.name = displayLineStyleName[3]
    lineOpaqueRateObj.editor = 'text'
    if (styleObject.opacity !== undefined) {
        lineOpaqueRateObj.value = styleObject.opacity
    } else {
        lineOpaqueRateObj.value = styleObject.strokeOpacity
    }

    //衬线：衬线类型
    const surroundLineTypeObj = new Object()
    surroundLineTypeObj.group = group[5]
    surroundLineTypeObj.name = displaySurroundLineName[0]
    surroundLineTypeObj.editor = {
        type: 'combobox',
        options: {
            valueField: 'value',
            textField: 'text',
            data: getSurroundLineTypeRows(selectfeature.symbolType),
        },
    }
    if (checkSymbolType(selectfeature) === true) {
        surroundLineTypeObj.value = surroundLineTypeToString(
            selectfeature.symbolType,
            selectfeature.getSurroundLineType()
        )
    }

    //衬线：衬线宽
    const surroundLineWidthObj = new Object()
    surroundLineWidthObj.group = group[5]
    surroundLineWidthObj.name = displaySurroundLineName[1]
    surroundLineWidthObj.editor = 'text'
    surroundLineWidthObj.value = styleObject.surroundLineWidth

    //衬线：衬线色
    const surroundLineColorObj = new Object()
    surroundLineColorObj.group = group[5]
    surroundLineColorObj.name = displaySurroundLineName[2]
    surroundLineColorObj.editor = 'colorpicker'
    surroundLineColorObj.value = styleObject.surroundLineColor

    //衬线：衬线透明度
    const surroundLineColorOpaObj = new Object()
    surroundLineColorOpaObj.group = group[5]
    surroundLineColorOpaObj.name = displaySurroundLineName[3]
    surroundLineColorOpaObj.editor = 'text'
    surroundLineColorOpaObj.value = styleObject.surroundLineColorOpacity

    //填充：填充
    const fillObj = new Object()
    fillObj.group = group[6]
    fillObj.name = displayFillStyleName[0]
    fillObj.editor = {
        type: 'combobox',
        options: {
            valueField: 'value',
            textField: 'text',
            data: getFillRows(selectfeature),
        },
    }
    fillObj.value = fillToString(
        parseFloat(styleObject.fillSymbolID),
        selectfeature
    )

    //填充：填充色
    const fillforeColorObj = new Object()
    fillforeColorObj.group = group[6]
    fillforeColorObj.name = displayFillStyleName[1]
    fillforeColorObj.editor = 'colorpicker'
    fillforeColorObj.value = styleObject.fillColor

    //填充：填充透明度
    const fillOpaqueRateObj = new Object()
    fillOpaqueRateObj.group = group[6]
    fillOpaqueRateObj.name = displayFillStyleName[2]
    fillOpaqueRateObj.editor = 'text'
    fillOpaqueRateObj.value = styleObject.fillOpacity

    //填充：渐变填充方式
    const fillGradientModeObj = new Object()
    fillGradientModeObj.group = group[6]
    fillGradientModeObj.name = displayFillStyleName[3]
    fillGradientModeObj.editor = {
        type: 'combobox',
        options: {
            valueField: 'value',
            textField: 'text',
            data: getFillGradientModeRows(),
        },
    }
    fillGradientModeObj.value = fillGradientModeToString(
        styleObject.fillGradientMode
    )

    //填充：填充背景色
    const fillBackColorObj = new Object()
    fillBackColorObj.group = group[6]
    fillBackColorObj.name = displayFillStyleName[4]
    fillBackColorObj.editor = 'colorpicker'
    fillBackColorObj.value = styleObject.fillBackColor

    //填充：填充背景透明度
    const fillBackOpacityObj = new Object()
    fillBackOpacityObj.group = group[6]
    fillBackOpacityObj.name = displayFillStyleName[5]
    fillBackOpacityObj.editor = 'text'
    fillBackOpacityObj.value = styleObject.fillBackOpacity

    //填充：渐变填充角度
    const fillBackAngleObj = new Object()
    fillBackAngleObj.group = group[6]
    fillBackAngleObj.name = displayFillStyleName[6]
    fillBackAngleObj.editor = 'text'
    fillBackAngleObj.value = styleObject.fillAngle

    //填充：渐变填充水平偏移
    const fillBackXObj = new Object()
    fillBackXObj.group = group[6]
    fillBackXObj.name = displayFillStyleName[7]
    fillBackXObj.editor = 'text'
    fillBackXObj.value = styleObject.fillCenterOffsetX

    //填充：渐变填充竖直偏移
    const fillBackYObj = new Object()
    fillBackYObj.group = group[6]
    fillBackYObj.name = displayFillStyleName[8]
    fillBackYObj.editor = 'text'
    fillBackYObj.value = styleObject.fillCenterOffsetY

    //注记：注记内容
    const textContentObj = new Object()
    textContentObj.group = group[7]
    textContentObj.name = displayTextContentName[0]
    textContentObj.editor = 'text'
    textContentObj.value = selectfeature.getTextContent()
    //注记：注记位置
    const markPosObj = new Object()
    markPosObj.group = group[7]
    markPosObj.name = displayTextContentName[1]
    if (selectfeature.symbolType === SuperMap.Plot.SymbolType.PATHTEXT) {
        markPosObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getRelLineTextRows(selectfeature.getRelLineText()),
            },
        }
        markPosObj.value = relLineTextToString(selectfeature.getRelLineText())
    } else {
        markPosObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getAnnotationRows(selectfeature),
            },
        }
        markPosObj.value = annotationToString(selectfeature.getTextPosition())
    }
    //注记：注记字体大小
    const fontSizeObj = new Object()
    fontSizeObj.group = group[7]
    fontSizeObj.name = displayTextContentName[2]
    fontSizeObj.editor = 'text'
    fontSizeObj.value = styleObject.fontSize

    //注记：注记字体颜色
    const fontColorObj = new Object()
    fontColorObj.group = group[7]
    fontColorObj.name = displayTextContentName[3]
    fontColorObj.editor = 'colorpicker'
    fontColorObj.value = styleObject.fontColor

    //注记：注记字体名称
    const fontFamilyObj = new Object()
    fontFamilyObj.group = group[7]
    fontFamilyObj.name = displayTextContentName[4]
    fontFamilyObj.editor = 'text'
    fontFamilyObj.value = styleObject.fontFamily

    //注记：注记与标号的间距
    const fontSpaceObj = new Object()
    fontSpaceObj.group = group[7]
    fontSpaceObj.name = displayTextContentName[5]
    fontSpaceObj.editor = 'text'
    if (
        selectfeature.symbolType === SuperMap.Plot.SymbolType.PATHTEXT ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.DOTSYMBOL
    ) {
        fontSpaceObj.value = selectfeature.getSpace()
    }
    //注记：字间距
    const fontSpaceObj1 = new Object()
    fontSpaceObj1.group = group[7]
    fontSpaceObj1.name = displayTextContentName[6]
    fontSpaceObj1.editor = 'text'
    fontSpaceObj1.value = styleObject.fontSpace

    //注记：字宽百分比
    const fontPercentObj = new Object()
    fontPercentObj.group = group[7]
    fontPercentObj.name = displayTextContentName[7]
    fontPercentObj.editor = 'text'
    fontPercentObj.value = styleObject.fontPercent
    //注记：字体描边
    const fontStrokeObj = new Object()
    fontStrokeObj.group = group[7]
    fontStrokeObj.name = displayTextContentName[8]
    fontStrokeObj.editor = {
        type: 'switch',
        options: { on: true, off: false },
    }
    fontStrokeObj.value = checkboxValueToString(styleObject.fontStroke)
    //注记：描边色
    const fontStrokeColorObj = new Object()
    fontStrokeColorObj.group = group[7]
    fontStrokeColorObj.name = displayTextContentName[9]
    fontStrokeColorObj.editor = 'colorpicker'
    fontStrokeColorObj.value = styleObject.fontStrokeColor
    //注记：描边宽度
    const fontStrokeWidthObj = new Object()
    fontStrokeWidthObj.group = group[7]
    fontStrokeWidthObj.name = displayTextContentName[10]
    fontStrokeWidthObj.editor = 'text'
    fontStrokeWidthObj.value = styleObject.fontStrokeWidth
    //注记：文字背景
    const fontBackObj = new Object()
    fontBackObj.group = group[7]
    fontBackObj.name = displayTextContentName[11]
    fontBackObj.editor = {
        type: 'switch',
        options: { on: true, off: false },
    }
    fontBackObj.value = checkboxValueToString(styleObject.fontBackground)
    //注记：背景色
    const fontBackColorObj = new Object()
    fontBackColorObj.group = group[7]
    fontBackColorObj.name = displayTextContentName[12]
    fontBackColorObj.editor = 'colorpicker'
    fontBackColorObj.value = styleObject.fontBackgroundColor
    //注记：文字阴影
    const fontShadowObj = new Object()
    fontShadowObj.group = group[7]
    fontShadowObj.name = displayTextContentName[13]
    fontShadowObj.editor = {
        type: 'switch',
        options: { on: true, off: false },
    }
    fontShadowObj.value = checkboxValueToString(styleObject.fontShadow)
    //注记：阴影色
    const fontShadowColorObj = new Object()
    fontShadowColorObj.group = group[7]
    fontShadowColorObj.name = displayTextContentName[14]
    fontShadowColorObj.editor = 'colorpicker'
    fontShadowColorObj.value = styleObject.fontShadowColor
    //注记：阴影偏移量X
    const fontShadowOffsetXObj = new Object()
    fontShadowOffsetXObj.group = group[7]
    fontShadowOffsetXObj.name = displayTextContentName[15]
    fontShadowOffsetXObj.editor = 'text'
    fontShadowOffsetXObj.value = styleObject.fontShadowOffsetX
    //注记：阴影偏移量Y
    const fontShadowOffsetYObj = new Object()
    fontShadowOffsetYObj.group = group[7]
    fontShadowOffsetYObj.name = displayTextContentName[16]
    fontShadowOffsetYObj.editor = 'text'
    fontShadowOffsetYObj.value = styleObject.fontShadowOffsetY

    let rows = []
    //线形
    const lineRows = []
    lineRows.push(lineWidthObj)
    lineRows.push(lineColorObj)
    lineRows.push(lineStyleObj)
    lineRows.push(lineOpaqueRateObj)
    //衬线
    const surroundLineRows = []
    surroundLineRows.push(surroundLineTypeObj)
    surroundLineRows.push(surroundLineWidthObj)
    surroundLineRows.push(surroundLineColorObj)
    surroundLineRows.push(surroundLineColorOpaObj)
    //填充
    const fillRows = []
    fillRows.push(fillObj)
    fillRows.push(fillGradientModeObj)
    if (
        styleObject.fillGradientMode === 'NONE' &&
        styleObject.fillSymbolID === 0
    ) {
        fillRows.push(fillforeColorObj)
        fillRows.push(fillOpaqueRateObj)
    } else if (
        styleObject.fillGradientMode === 'NONE' &&
        styleObject.fillSymbolID !== 0 &&
        styleObject.fillSymbolID !== 1
    ) {
        fillRows.push(fillforeColorObj)
        fillRows.push(fillOpaqueRateObj)
        fillRows.push(fillBackColorObj)
        fillRows.push(fillBackOpacityObj)
    } else if (styleObject.fillGradientMode !== 'NONE') {
        fillRows.push(fillforeColorObj)
        fillRows.push(fillOpaqueRateObj)
        fillRows.push(fillBackColorObj)
        if (styleObject.fillGradientMode === 'LINEAR') {
            fillRows.push(fillBackAngleObj)
        }
        fillRows.push(fillBackXObj)
        if (styleObject.fillGradientMode === 'RADIAL') {
            fillRows.push(fillBackYObj)
        }
    }

    //文字
    const textRows = []
    textRows.push(textContentObj)
    textRows.push(fontColorObj)
    textRows.push(fontFamilyObj)
    textRows.push(fontSizeObj)
    if (
        selectfeature.symbolType === SuperMap.Plot.SymbolType.PATHTEXT ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.DOTSYMBOL
    ) {
        textRows.push(markPosObj)
        if (selectfeature.getTextPosition() !== 8) {
            textRows.push(fontSpaceObj)
        }
    }
    if (
        selectfeature.symbolType === SuperMap.Plot.SymbolType.DOTSYMBOL ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.TEXTSYMBOL
    ) {
        textRows.push(fontPercentObj)
        textRows.push(fontSpaceObj1)
        textRows.push(fontStrokeObj)
        if (styleObject.fontStroke === true) {
            textRows.push(fontStrokeColorObj)
            textRows.push(fontStrokeWidthObj)
        }
        textRows.push(fontBackObj)
        if (styleObject.fontBackground === true) {
            textRows.push(fontBackColorObj)
        }
        textRows.push(fontShadowObj)
        if (styleObject.fontShadow === true) {
            textRows.push(fontShadowColorObj)
            textRows.push(fontShadowOffsetXObj)
            textRows.push(fontShadowOffsetYObj)
        }
    }

    //图元文本
    if (selectfeature.symbolType === SuperMap.Plot.SymbolType.TEXTSYMBOL) {
        rows = rows.concat(textRows)
    }
    if (
        selectfeature.symbolType === SuperMap.Plot.SymbolType.GROUPOBJECT ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.FLAGGROUP ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.AIRROUTE ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.NAVYROUTE ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.MISSILEROUTE ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.LITERATESIGN ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.AIRDEPLOYMENT ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.SYMBOLTEXT1 ||
        selectfeature.symbolType ===
            SuperMap.Plot.SymbolType.SATELLITETIMEWINDOWS ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.NAVYDEPLOYMENT
    ) {
        rows = rows.concat(lineRows)
        if (
            selectfeature.symbolType ===
                SuperMap.Plot.SymbolType.AIRDEPLOYMENT ||
            selectfeature.symbolType === SuperMap.Plot.SymbolType.NAVYDEPLOYMENT
        ) {
            rows = rows.concat(fillRows)
        }
        if (
            selectfeature.symbolType ===
                SuperMap.Plot.SymbolType.NAVYDEPLOYMENT ||
            selectfeature.symbolType === SuperMap.Plot.SymbolType.SYMBOLTEXT1
        ) {
            rows.push(textContentObj)
            rows.push(fontColorObj)
            rows.push(fontFamilyObj)
            rows.push(fontSizeObj)
        }
    }

    //点标号自己独有属性
    if (selectfeature.symbolType === SuperMap.Plot.SymbolType.DOTSYMBOL) {
        //常用：点：旋转角度
        const dotSymbolRotateObj = new Object()
        dotSymbolRotateObj.group = group[3]
        dotSymbolRotateObj.name = displayNameDot[0]
        dotSymbolRotateObj.editor = 'text'
        dotSymbolRotateObj.value = selectfeature.getRotate()
        //常用：点：随图缩放
        const dotScaleByMap = new Object()
        dotScaleByMap.group = group[3]
        dotScaleByMap.name = displayNameDot[1]
        dotScaleByMap.editor = {
            type: 'switch',
            options: { on: true, off: false },
        }
        dotScaleByMap.value = checkboxValueToString(
            selectfeature.getScaleByMap()
        )
        //常用：点：镜像
        const dotSymbolNegativeImageObj = new Object()
        dotSymbolNegativeImageObj.group = group[3]
        dotSymbolNegativeImageObj.name = displayNameDot[2]
        dotSymbolNegativeImageObj.editor = {
            type: 'switch',
            options: { on: true, off: false },
        }
        dotSymbolNegativeImageObj.value = checkboxValueToString(
            selectfeature.getNegativeImage()
        )
        //常用：点：标号级别
        const dotSymbolRankObj = new Object()
        dotSymbolRankObj.group = group[3]
        dotSymbolRankObj.name = displayNameDot[3]
        dotSymbolRankObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getSymbolRankRows(selectfeature),
            },
        }
        dotSymbolRankObj.value = symbolRankToString(
            selectfeature.getSymbolRank()
        )
        //常用：点：位置点偏移
        const dotPositionOffset = new Object()
        dotPositionOffset.group = group[3]
        dotPositionOffset.name = displayNameDot[4]
        dotPositionOffset.editor = {
            type: 'switch',
            options: { on: true, off: false },
        }
        dotPositionOffset.value = checkboxValueToString(
            selectfeature.getPositionOffset()
        )
        //常用：点：偏移线类型
        const dotPositionOffsetType = new Object()
        dotPositionOffsetType.group = group[3]
        dotPositionOffsetType.name = displayNameDot[5]
        dotPositionOffsetType.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getPositionOffsetTypeRows(),
            },
        }
        dotPositionOffsetType.value = positionOffsetTypeToString(
            selectfeature.getPositionOffsetType()
        )
        //常用：点:宽高限定
        const dotSymbolWidthHeightLimit = new Object()
        dotSymbolWidthHeightLimit.group = group[3]
        dotSymbolWidthHeightLimit.name = displayNameDot[6]
        dotSymbolWidthHeightLimit.editor = {
            type: 'switch',
            options: { on: true, off: false },
        }
        dotSymbolWidthHeightLimit.value = checkboxValueToString(
            selectfeature.getWidthHeightLimit()
        )
        //常用：点：军标大小
        const dotSymbolWidthObj = new Object()
        dotSymbolWidthObj.group = group[3]
        dotSymbolWidthObj.name = displayNameDot[7]
        dotSymbolWidthObj.editor = 'text'
        dotSymbolWidthObj.value = selectfeature.getSymbolSize().w
        const dotSymbolHeightObj = new Object()
        dotSymbolHeightObj.group = group[3]
        dotSymbolHeightObj.name = displayNameDot[8]
        dotSymbolHeightObj.editor = 'text'
        dotSymbolHeightObj.value = selectfeature.getSymbolSize().h

        let dotSymbolRows = []
        dotSymbolRows.push(dotSymbolRotateObj)
        dotSymbolRows.push(dotScaleByMap)
        dotSymbolRows.push(dotSymbolNegativeImageObj)
        dotSymbolRows.push(dotSymbolRankObj)
        dotSymbolRows.push(dotPositionOffset)
        dotSymbolRows.push(dotPositionOffsetType)
        dotSymbolRows.push(dotSymbolWidthHeightLimit)
        dotSymbolRows.push(dotSymbolWidthObj)
        dotSymbolRows.push(dotSymbolHeightObj)
        dotSymbolRows = dotSymbolRows.concat(lineRows)
        dotSymbolRows = dotSymbolRows.concat(surroundLineRows)
        dotSymbolRows = dotSymbolRows.concat(fillRows)
        dotSymbolRows = dotSymbolRows.concat(textRows)
        rows = rows.concat(dotSymbolRows)
    }

    let i = 0

    if (
        selectfeature.symbolType !== SuperMap.Plot.SymbolType.DOTSYMBOL &&
        checkSymbolType(selectfeature) === true
    ) {
        let algoSymbolRows = []
        //线面标号子标号
        for (i = 0; i < selectfeature.getSubSymbols().length; i++) {
            const objectSubCode = new Object()
            objectSubCode.group = group[8]
            objectSubCode.name = displayName[3]
            objectSubCode.editor = {
                type: 'combobox',
                options: {
                    valueField: 'value',
                    textField: 'text',
                    data: getSubSymbolsTypeRows(selectfeature),
                },
            }
            objectSubCode.index = i
            objectSubCode.value = selectfeature.getSubSymbols()[i].code
            algoSymbolRows.push(objectSubCode)
        }
        if (
            (0 === selectfeature.getSubSymbols().length &&
                selectfeature.libID === 0 &&
                selectfeature.code === 1025) ||
            (0 === selectfeature.getSubSymbols().length &&
                selectfeature.libID === 100 &&
                selectfeature.code === 25200) ||
            (0 === selectfeature.getSubSymbols().length &&
                selectfeature.libID === 100 &&
                selectfeature.code === 3020901) ||
            (0 === selectfeature.getSubSymbols().length &&
                selectfeature.libID === 100 &&
                selectfeature.code === 23400) ||
            (0 === selectfeature.getSubSymbols().length &&
                selectfeature.libID === 100 &&
                selectfeature.code === 30800) ||
            (0 === selectfeature.getSubSymbols().length &&
                selectfeature.libID === 100 &&
                selectfeature.code === 26400)
        ) {
            const objectSubCode1 = new Object()
            objectSubCode1.group = group[8]
            objectSubCode1.name = displayName[3]
            objectSubCode1.editor = {
                type: 'combobox',
                options: {
                    valueField: 'value',
                    textField: 'text',
                    data: getSubSymbolsTypeRows(selectfeature),
                },
            }
            objectSubCode1.index = i
            objectSubCode1.value = subSymbolsTypeString(
                selectfeature.getSubSymbols().length,
                selectfeature
            )
            algoSymbolRows.push(objectSubCode1)
        }
        if (
            selectfeature.code === 1025 &&
            selectfeature.getSubSymbols().length > 0
        ) {
            const objectLibID = new Object()
            objectLibID.group = group[8]
            objectLibID.name = displayName[2]
            objectLibID.editor = 'text'
            objectLibID.value = libIDToString(
                selectfeature.getSubSymbols()[0].libID
            )
            algoSymbolRows.push(objectLibID)
        }
        //四个点以上含4个点可以设置成折线显示
        if (
            selectfeature.getLatLngs().length > 3 &&
            typeof selectfeature.canPolylineConnectLocationPoint !==
                'undefined' &&
            selectfeature.canPolylineConnectLocationPoint() === true
        ) {
            const algoLineType = new Object()
            algoLineType.group = groupNew[8]
            algoLineType.name = displayNameNew[20]
            algoLineType.editor = {
                type: 'switch',
                options: { on: true, off: false },
            }
            algoLineType.value = checkboxValueToString(
                selectfeature.getPolylineConnectLocationPoint()
            )
            algoSymbolRows.push(algoLineType)
        }
        algoSymbolRows = algoSymbolRows.concat(lineRows)
        algoSymbolRows = algoSymbolRows.concat(surroundLineRows)
        algoSymbolRows = algoSymbolRows.concat(fillRows)
        if (isCanAddText(selectfeature) === true) {
            algoSymbolRows = algoSymbolRows.concat(textRows)
        }
        rows = rows.concat(algoSymbolRows)
    }

    //注记指示框、多角标注框、标注框、线型标注框
    if (
        selectfeature.symbolType === SuperMap.Plot.SymbolType.ANNOFRAMESYMBOL ||
        selectfeature.symbolType ===
            SuperMap.Plot.SymbolType.ANNOFRAMESYMBOLM ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.SYMBOLTEXTBOX ||
        selectfeature.symbolType === SuperMap.Plot.SymbolType.LINEMARKING
    ) {
        //文字对齐方式
        const fontAlignType = new Object()
        fontAlignType.group = group[7]
        fontAlignType.name = displayNameNew[21]
        fontAlignType.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getFontAlignTypeRows(),
            },
        }
        fontAlignType.value = fontAlignTypeToString(styleObject.labelAlign)
        rows.push(fontAlignType)
        //标注框边框
        if (
            selectfeature.symbolType === SuperMap.Plot.SymbolType.SYMBOLTEXTBOX
        ) {
            //标注框边框
            const textBoxTypeObj = new Object()
            textBoxTypeObj.group = groupNew[3]
            textBoxTypeObj.name = displayNameNew[9]
            textBoxTypeObj.editor = {
                type: 'combobox',
                options: {
                    valueField: 'value',
                    textField: 'text',
                    data: getTextBoxTypeRows(),
                },
            }
            textBoxTypeObj.value = textBoxTypeToString(
                selectfeature.getTextBoxType()
            )
            //圆角边框
            const roundBoxObj = new Object()
            roundBoxObj.group = groupNew[3]
            roundBoxObj.name = displayNameNew[10]
            roundBoxObj.editor = {
                type: 'switch',
                options: { on: true, off: false },
            }
            roundBoxObj.value = checkboxValueToString(
                selectfeature.getRoundBox()
            )

            rows.push(textBoxTypeObj)
            rows.push(roundBoxObj)
        }
        //线型标注框边框
        if (selectfeature.symbolType === SuperMap.Plot.SymbolType.LINEMARKING) {
            const lineMarkingTextBoxTypeObj = new Object()
            lineMarkingTextBoxTypeObj.group = groupNew[3]
            lineMarkingTextBoxTypeObj.name = displayNameNew[9]
            lineMarkingTextBoxTypeObj.editor = {
                type: 'combobox',
                options: {
                    valueField: 'value',
                    textField: 'text',
                    data: getLineMarkingTypeRows(),
                },
            }
            lineMarkingTextBoxTypeObj.value = lineMarkingTypeToString(
                selectfeature.getTextBoxType()
            )
            rows.push(lineMarkingTextBoxTypeObj)
        }
    }

    //箭头线自己独有属性
    if (
        selectfeature.symbolType === SuperMap.Plot.SymbolType.ARROWLINE &&
        selectfeature.libID === 0
    ) {
        const arrowTypeStartObj = new Object()
        arrowTypeStartObj.group = groupNew[1]
        arrowTypeStartObj.name = displayNameNew[3]
        arrowTypeStartObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getArrowTypeRows(selectfeature),
            },
        }
        arrowTypeStartObj.value = arrowTypeToString(
            selectfeature.getStartArrowType()
        )
        const arrowTypeEndObj = new Object()
        arrowTypeEndObj.group = groupNew[1]
        arrowTypeEndObj.name = displayNameNew[4]
        arrowTypeEndObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getArrowTypeRows(selectfeature),
            },
        }
        arrowTypeEndObj.value = arrowTypeToString(
            selectfeature.getEndArrowType()
        )
        rows.push(arrowTypeStartObj)
        rows.push(arrowTypeEndObj)
    }

    //沿线注记自己独有属性
    if (selectfeature.symbolType === SuperMap.Plot.SymbolType.PATHTEXT) {
        const showPathLineObj = new Object()
        showPathLineObj.group = groupNew[2]
        showPathLineObj.name = displayNameNew[5]
        showPathLineObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getShowRows(),
            },
        }
        showPathLineObj.value = showToString(selectfeature.getShowPathLine())
        const isCurveObj = new Object()
        isCurveObj.group = groupNew[2]
        isCurveObj.name = displayNameNew[6]
        isCurveObj.editor = {
            type: 'switch',
            options: { on: true, off: false },
        }
        isCurveObj.value = checkboxValueToString(selectfeature.getIsCurveLine())
        const showPathLineArrowObj = new Object()
        showPathLineArrowObj.group = groupNew[2]
        showPathLineArrowObj.name = displayNameNew[7]
        showPathLineArrowObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getShowRows(),
            },
        }
        showPathLineArrowObj.value = showToString(
            selectfeature.getShowPathLineArrow()
        )
        const isAvoidObj = new Object()
        isAvoidObj.group = groupNew[2]
        isAvoidObj.name = displayNameNew[8]
        isAvoidObj.editor = {
            type: 'switch',
            options: { on: true, off: false },
        }
        isAvoidObj.value = checkboxValueToString(selectfeature.getIsAvoidLine())
        rows.push(showPathLineObj)
        rows.push(isCurveObj)
        rows.push(showPathLineArrowObj)
        if (
            selectfeature.getRelLineText() === SuperMap.Plot.RelLineText.ONLINE
        ) {
            rows.push(isAvoidObj)
        }
    }

    //对象间连线
    if (selectfeature.symbolType === SuperMap.Plot.SymbolType.LINERELATION) {
        const lineRelationTypeObj = new Object()
        lineRelationTypeObj.name = displayNameNew[19]
        lineRelationTypeObj.value = lineRelationTypeToString(
            selectfeature.getLineRelationType()
        )
        lineRelationTypeObj.group = groupNew[7]
        lineRelationTypeObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getLineRelationTypeRows(),
            },
        }
        rows.push(lineRelationTypeObj)
    }
    //扇形区域
    if (selectfeature.symbolType === SuperMap.Plot.SymbolType.ARCREGION) {
        if (selectfeature.radiusLineType != null) {
            const radiusLineTypeObj = new Object()
            radiusLineTypeObj.name = displayNameNew[12]
            radiusLineTypeObj.value = radiusTypeToString(
                selectfeature.getRadiusLineType()
            )
            radiusLineTypeObj.group = groupNew[4]
            radiusLineTypeObj.editor = {
                type: 'combobox',
                options: {
                    valueField: 'value',
                    textField: 'text',
                    data: getRadiusTypeRows(selectfeature),
                },
            }
            rows.push(radiusLineTypeObj)
        }
        if (selectfeature.radiusText != null) {
            const radiusPosAngleObj = new Object()
            radiusPosAngleObj.name = displayNameNew[13]
            radiusPosAngleObj.value = selectfeature.getRadiusTextPos()
            radiusPosAngleObj.group = groupNew[4]
            radiusPosAngleObj.editor = 'text'
            const upTextObj = new Object()
            upTextObj.name = displayNameNew[14]
            upTextObj.value = selectfeature.getRadiusText(0)
            upTextObj.group = groupNew[4]
            upTextObj.editor = 'text'
            const downTextObj = new Object()
            downTextObj.name = displayNameNew[15]
            downTextObj.value = selectfeature.getRadiusText(1)
            downTextObj.group = groupNew[4]
            downTextObj.editor = 'text'

            rows.push(radiusPosAngleObj)
            rows.push(upTextObj)
            rows.push(downTextObj)
        }
    }

    //航线
    if (selectfeature.symbolType === SuperMap.Plot.SymbolType.ROUTENODE) {
        rows = rows.concat(lineRows)
        const routeNodeTypeObj = new Object()
        routeNodeTypeObj.name = displayNameNew[17]
        routeNodeTypeObj.value = routeNodeTypeToString(
            selectfeature.routeNode.type
        )
        routeNodeTypeObj.group = groupNew[6]
        routeNodeTypeObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getRouteNodeTypeRows(),
            },
        }
        const routeNodeRotate = new Object()
        routeNodeRotate.name = displayNameNew[18]
        routeNodeRotate.value = selectfeature.routeNode.rotate
        routeNodeRotate.group = groupNew[6]
        routeNodeRotate.editor = 'text'
        rows.push(routeNodeTypeObj)
        if (
            selectfeature.routeNode.type === SuperMap.Plot.RouteNodeType.STANDBY
        ) {
            rows.push(routeNodeRotate)
        }
    }

    //对象标注的标注内容和标注边框
    if (selectfeature.symbolType === SuperMap.Plot.SymbolType.SYMBOLTEXT) {
        const textContentObj1 = new Object()
        textContentObj1.group = group[7]
        textContentObj1.name = displayTextContentName[0]
        textContentObj1.editor = 'text'
        textContentObj1.value = selectfeature.symbolTexts[0].textContent
        rows.push(textContentObj1)
        if (selectfeature.symbolTexts.length == 2) {
            const textContentObj2 = new Object()
            textContentObj2.group = group[7]
            textContentObj2.name = displayTextContentName[0] + '2'
            textContentObj2.editor = 'text'
            textContentObj2.value = selectfeature.symbolTexts[1].textContent
            rows.push(textContentObj2)
        }
        rows.push(fontColorObj)
        rows.push(fontFamilyObj)
        rows.push(fontSizeObj)
        const symbolTextFrameObj = new Object()
        symbolTextFrameObj.group = groupNew[3]
        symbolTextFrameObj.name = displayNameNew[11]
        symbolTextFrameObj.editor = {
            type: 'switch',
            options: { on: true, off: false },
        }
        symbolTextFrameObj.value = checkboxValueToString(
            selectfeature.getFrame()
        )
        rows.push(symbolTextFrameObj)
        if (selectfeature.getFrame() === true) {
            rows.push(lineWidthObj)
            rows.push(lineColorObj)
            rows.push(lineOpaqueRateObj)
            rows.push(fillObj)
            rows.push(fillforeColorObj)
            rows.push(fillOpaqueRateObj)
        }
    }

    //卫星
    if (selectfeature.symbolType === SuperMap.Plot.SymbolType.SATELLITE) {
        const visibleObj = new Object()
        visibleObj.name = displayNameNew[16]
        visibleObj.value = showToString(selectfeature.getVisible())
        visibleObj.group = groupNew[5]
        visibleObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getShowRows(),
            },
        }
        rows = rows.concat(lineRows)
        rows.push(textContentObj)
        rows.push(fontColorObj)
        rows.push(fontFamilyObj)
        rows.push(fontSizeObj)
        rows.push(visibleObj)
    }

    //复合箭头自己独有属性
    if (selectfeature.libID === 22 && selectfeature.code === 1016) {
        const arrowHeadTypeObj = new Object()
        arrowHeadTypeObj.group = groupNew[0]
        arrowHeadTypeObj.name = displayNameNew[0]
        arrowHeadTypeObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getArrowHeadTypeRows(),
            },
        }
        arrowHeadTypeObj.value = arrowHeadTypeToString(
            selectfeature.getArrowHeadType()
        )

        const arrowBodyTypeObj = new Object()
        arrowBodyTypeObj.group = groupNew[0]
        arrowBodyTypeObj.name = displayNameNew[1]
        arrowBodyTypeObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getArrowBodyTypeRows(),
            },
        }
        arrowBodyTypeObj.value = arrowBodyTypeToString(
            selectfeature.getArrowBodyType()
        )

        const arrowTailTypepeObj = new Object()
        arrowTailTypepeObj.group = groupNew[0]
        arrowTailTypepeObj.name = displayNameNew[2]
        arrowTailTypepeObj.editor = {
            type: 'combobox',
            options: {
                valueField: 'value',
                textField: 'text',
                data: getArrowTailTypeRows(),
            },
        }
        arrowTailTypepeObj.value = arrowTailTypeToString(
            selectfeature.getArrowTailType()
        )

        rows.push(arrowHeadTypeObj)
        rows.push(arrowBodyTypeObj)
        rows.push(arrowTailTypepeObj)
    }
    return rows
}

/**
 * 获取要素样式
 * @param {Array} featuresParameter
 * @returns {Object}
 */
export function collectionPropertyGridRows(featuresParameter) {
    const features = []
    const styles = []
    for (let i = 0; i < featuresParameter.length; i++) {
        styles.push(featuresParameter[i].style)
        if (featuresParameter[i].geometry === undefined) {
            features.push(featuresParameter[i])
        } else {
            features.push(featuresParameter[i].geometry)
        }
    }
    let rows = []
    if (features.length === 0) {
        return (rows = [])
    }
    const dotSelectFeatures = []
    const algoSelectFeatures = []
    const sameFeatures = []
    const otherFeatures = []
    let selectfeatures = []
    for (let i = 0; i < features.length; i++) {
        if (
            features[i].libID === features[0].libID &&
            features[i].code === features[0].code
        ) {
            sameFeatures.push(features[i]) //是否是同一个标号
        }
    }
    if (sameFeatures.length !== features.length) {
        for (let i = 0; i < features.length; i++) {
            if (features[i].symbolType === SuperMap.Plot.SymbolType.DOTSYMBOL) {
                dotSelectFeatures.push(features[i]) //是否全是不同点标号
            } else if (
                features[i].symbolType === SuperMap.Plot.SymbolType.ALGOSYMBOL
            ) {
                algoSelectFeatures.push(features[i]) //是否全是不同线面标号
            } else {
                otherFeatures.push(features[i])
            }
        }
    }
    if (sameFeatures.length === features.length) {
        selectfeatures = features
    } else if (dotSelectFeatures.length === features.length) {
        selectfeatures = dotSelectFeatures
    } else if (algoSelectFeatures.length === features.length) {
        selectfeatures = algoSelectFeatures
    } else if (
        dotSelectFeatures.length > 0 &&
        algoSelectFeatures.length > 0 &&
        otherFeatures.length === 0
    ) {
        selectfeatures = features
    } else if (otherFeatures.length > 0) {
        selectfeatures = features
    }
    const selectfeature = selectfeatures[0]
    const styleObject = styles[0]

    if (selectfeatures.length === sameFeatures.length) {
        rows = [
            {
                name: '标号几何ID',
                value: selectfeature.symbolType,
                group: group[0],
            },
            { name: '标号库ID', value: selectfeature.libID, group: group[0] },
            { name: '标号Code', value: selectfeature.code, group: group[0] },
            {
                name: '标号名字',
                value: selectfeature.symbolName,
                group: group[0],
            },
        ]
    }

    //标号锁定
    const lockedObj = new Object()
    lockedObj.group = group[1]
    lockedObj.name = displayName[0]
    lockedObj.editor = { type: 'switch', options: { on: true, off: false } }
    lockedObj.value = checkboxValueToString(selectfeature.getLocked())
    //标号可见性
    const visibilityObj = new Object()
    visibilityObj.group = group[2]
    visibilityObj.name = displayName[1]
    visibilityObj.editor = {
        type: 'combobox',
        options: {
            valueField: 'value',
            textField: 'text',
            data: getDisplayRows(),
        },
    }
    //visibilityObj.value = displayToString(selectfeature.style.display);
    visibilityObj.value = displayToString(styleObject.display)
    rows.push(lockedObj)
    if (selectfeature.getLocked()) {
        return rows
    }
    rows.push(visibilityObj)
    if (
        selectfeatures.length === sameFeatures.length ||
        selectfeatures.length === dotSelectFeatures.length ||
        selectfeatures.length === algoSelectFeatures.length
    ) {
        rows = rows.concat(symbolPropertyObject(selectfeature, styleObject))
    }
    //addExtendProperty(rows,selectfeature);
    return rows
}
